	.text
	.file	"lulesh-util.opt.bc"
	.globl	_Z8StrToIntPKcPi
	.align	16, 0x90
	.type	_Z8StrToIntPKcPi,@function
_Z8StrToIntPKcPi:                       # @_Z8StrToIntPKcPi
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp0:
	.cfi_def_cfa_offset 16
.Ltmp1:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp2:
	.cfi_def_cfa_register %rbp
	subq	$48, %rsp
	movq	%rdi, -16(%rbp)
	movq	%rsi, -24(%rbp)
	movl	$10, -44(%rbp)
	cmpq	$0, -16(%rbp)
	je	.LBB0_5
# BB#1:                                 # %if.end
	movq	-16(%rbp), %rdi
	movq	%rdi, -32(%rbp)
	leaq	-40(%rbp), %rsi
	movl	$10, %edx
	callq	strtol
	movq	-24(%rbp), %rcx
	movl	%eax, (%rcx)
	movq	-40(%rbp), %rax
	cmpq	-32(%rbp), %rax
	je	.LBB0_5
# BB#2:                                 # %land.lhs.true
	movq	-40(%rbp), %rax
	movsbl	(%rax), %eax
	cmpl	$32, %eax
	je	.LBB0_4
# BB#3:                                 # %lor.lhs.false
	movq	-40(%rbp), %rax
	movsbl	(%rax), %eax
	testl	%eax, %eax
	je	.LBB0_4
.LBB0_5:                                # %if.else
	movl	$0, -4(%rbp)
	jmp	.LBB0_6
.LBB0_4:                                # %if.then6
	movl	$1, -4(%rbp)
.LBB0_6:                                # %return
	movl	-4(%rbp), %eax
	addq	$48, %rsp
	popq	%rbp
	retq
.Ltmp3:
	.size	_Z8StrToIntPKcPi, .Ltmp3-_Z8StrToIntPKcPi
	.cfi_endproc

	.globl	_Z23ParseCommandLineOptionsiPPciP11cmdLineOpts
	.align	16, 0x90
	.type	_Z23ParseCommandLineOptionsiPPciP11cmdLineOpts,@function
_Z23ParseCommandLineOptionsiPPciP11cmdLineOpts: # @_Z23ParseCommandLineOptionsiPPciP11cmdLineOpts
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp4:
	.cfi_def_cfa_offset 16
.Ltmp5:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp6:
	.cfi_def_cfa_register %rbp
	pushq	%rbx
	subq	$120, %rsp
.Ltmp7:
	.cfi_offset %rbx, -24
	movl	%edi, -12(%rbp)
	movq	%rsi, -24(%rbp)
	movl	%edx, -28(%rbp)
	movq	%rcx, -40(%rbp)
	cmpl	$2, -12(%rbp)
	jl	.LBB1_47
# BB#1:                                 # %if.then
	movl	$1, -44(%rbp)
	leaq	-128(%rbp), %rbx
	jmp	.LBB1_2
	.align	16, 0x90
.LBB1_8:                                # %if.end11
                                        #   in Loop: Header=BB1_2 Depth=1
	addl	$2, -44(%rbp)
.LBB1_2:                                # %while.cond
                                        # =>This Inner Loop Header: Depth=1
	movl	-44(%rbp), %eax
	cmpl	-12(%rbp), %eax
	jge	.LBB1_47
# BB#3:                                 # %while.body
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_4
# BB#9:                                 # %if.else
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str3, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_10
# BB#15:                                # %if.else30
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str6, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_16
# BB#21:                                # %if.else48
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str9, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_22
# BB#27:                                # %if.else66
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str12, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_28
# BB#29:                                # %if.else72
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str13, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_30
# BB#31:                                # %if.else79
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str14, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_32
# BB#37:                                # %if.else97
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str17, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_38
# BB#43:                                # %if.else115
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str20, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_44
# BB#45:                                # %if.else122
                                        #   in Loop: Header=BB1_2 Depth=1
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movl	$.L.str22, %esi
	callq	strcmp
	testl	%eax, %eax
	je	.LBB1_48
# BB#46:                                # %if.else129
                                        #   in Loop: Header=BB1_2 Depth=1
	movq	-24(%rbp), %rax
	movq	(%rax), %rdi
	movl	-28(%rbp), %esi
	callq	_ZL23PrintCommandLineOptionsPci
	movslq	-44(%rbp), %rax
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdx
	movl	$.L.str23, %esi
	xorl	%eax, %eax
	movq	%rbx, %rdi
	callq	sprintf
	movl	-28(%rbp), %esi
	movq	%rbx, %rdi
	callq	_ZL10ParseErrorPKci
	jmp	.LBB1_2
	.align	16, 0x90
.LBB1_4:                                # %if.then3
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cmpl	-12(%rbp), %eax
	jl	.LBB1_6
# BB#5:                                 # %if.then5
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str1, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_6:                                # %if.end
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cltq
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movq	-40(%rbp), %rsi
	callq	_Z8StrToIntPKcPi
	movl	%eax, -48(%rbp)
	testl	%eax, %eax
	jne	.LBB1_8
# BB#7:                                 # %if.then10
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str2, %edi
	callq	_ZL10ParseErrorPKci
	jmp	.LBB1_8
	.align	16, 0x90
.LBB1_10:                               # %if.then17
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cmpl	-12(%rbp), %eax
	jl	.LBB1_12
# BB#11:                                # %if.then20
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str4, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_12:                               # %if.end21
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cltq
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movq	-40(%rbp), %rsi
	addq	$4, %rsi
	callq	_Z8StrToIntPKcPi
	movl	%eax, -48(%rbp)
	testl	%eax, %eax
	jne	.LBB1_14
# BB#13:                                # %if.then27
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str5, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_14:                               # %if.end28
                                        #   in Loop: Header=BB1_2 Depth=1
	addl	$2, -44(%rbp)
	jmp	.LBB1_2
.LBB1_16:                               # %if.then35
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cmpl	-12(%rbp), %eax
	jl	.LBB1_18
# BB#17:                                # %if.then38
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str7, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_18:                               # %if.end39
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cltq
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movq	-40(%rbp), %rsi
	addq	$8, %rsi
	callq	_Z8StrToIntPKcPi
	movl	%eax, -48(%rbp)
	testl	%eax, %eax
	jne	.LBB1_20
# BB#19:                                # %if.then45
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str8, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_20:                               # %if.end46
                                        #   in Loop: Header=BB1_2 Depth=1
	addl	$2, -44(%rbp)
	jmp	.LBB1_2
.LBB1_22:                               # %if.then53
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cmpl	-12(%rbp), %eax
	jl	.LBB1_24
# BB#23:                                # %if.then56
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str10, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_24:                               # %if.end57
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cltq
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movq	-40(%rbp), %rsi
	addq	$12, %rsi
	callq	_Z8StrToIntPKcPi
	movl	%eax, -48(%rbp)
	testl	%eax, %eax
	jne	.LBB1_26
# BB#25:                                # %if.then63
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str11, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_26:                               # %if.end64
                                        #   in Loop: Header=BB1_2 Depth=1
	addl	$2, -44(%rbp)
	jmp	.LBB1_2
.LBB1_28:                               # %if.then71
                                        #   in Loop: Header=BB1_2 Depth=1
	movq	-40(%rbp), %rax
	movl	$1, 16(%rax)
	incl	-44(%rbp)
	jmp	.LBB1_2
.LBB1_30:                               # %if.then77
                                        #   in Loop: Header=BB1_2 Depth=1
	movq	-40(%rbp), %rax
	movl	$1, 20(%rax)
	incl	-44(%rbp)
	jmp	.LBB1_2
.LBB1_32:                               # %if.then84
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cmpl	-12(%rbp), %eax
	jl	.LBB1_34
# BB#33:                                # %if.then87
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str15, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_34:                               # %if.end88
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cltq
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movq	-40(%rbp), %rsi
	addq	$32, %rsi
	callq	_Z8StrToIntPKcPi
	movl	%eax, -48(%rbp)
	testl	%eax, %eax
	jne	.LBB1_36
# BB#35:                                # %if.then94
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str16, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_36:                               # %if.end95
                                        #   in Loop: Header=BB1_2 Depth=1
	addl	$2, -44(%rbp)
	jmp	.LBB1_2
.LBB1_38:                               # %if.then102
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cmpl	-12(%rbp), %eax
	jl	.LBB1_40
# BB#39:                                # %if.then105
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str18, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_40:                               # %if.end106
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-44(%rbp), %eax
	incl	%eax
	cltq
	movq	-24(%rbp), %rcx
	movq	(%rcx,%rax,8), %rdi
	movq	-40(%rbp), %rsi
	addq	$28, %rsi
	callq	_Z8StrToIntPKcPi
	movl	%eax, -48(%rbp)
	testl	%eax, %eax
	jne	.LBB1_42
# BB#41:                                # %if.then112
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str19, %edi
	callq	_ZL10ParseErrorPKci
.LBB1_42:                               # %if.end113
                                        #   in Loop: Header=BB1_2 Depth=1
	addl	$2, -44(%rbp)
	jmp	.LBB1_2
.LBB1_44:                               # %if.then120
                                        #   in Loop: Header=BB1_2 Depth=1
	movl	-28(%rbp), %esi
	movl	$.L.str21, %edi
	callq	_ZL10ParseErrorPKci
	incl	-44(%rbp)
	jmp	.LBB1_2
.LBB1_47:                               # %if.end145
	addq	$120, %rsp
	popq	%rbx
	popq	%rbp
	retq
.LBB1_48:                               # %if.then127
	movq	-24(%rbp), %rax
	movq	(%rax), %rdi
	movl	-28(%rbp), %esi
	callq	_ZL23PrintCommandLineOptionsPci
	xorl	%edi, %edi
	callq	exit
.Ltmp8:
	.size	_Z23ParseCommandLineOptionsiPPciP11cmdLineOpts, .Ltmp8-_Z23ParseCommandLineOptionsiPPciP11cmdLineOpts
	.cfi_endproc

	.align	16, 0x90
	.type	_ZL10ParseErrorPKci,@function
_ZL10ParseErrorPKci:                    # @_ZL10ParseErrorPKci
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp9:
	.cfi_def_cfa_offset 16
.Ltmp10:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp11:
	.cfi_def_cfa_register %rbp
	subq	$16, %rsp
	movq	%rdi, -8(%rbp)
	movl	%esi, -12(%rbp)
	testl	%esi, %esi
	je	.LBB2_2
# BB#1:                                 # %if.end
	addq	$16, %rsp
	popq	%rbp
	retq
.LBB2_2:                                # %if.then
	movq	-8(%rbp), %rsi
	movl	$.L.str49, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$-1, %edi
	callq	exit
.Ltmp12:
	.size	_ZL10ParseErrorPKci, .Ltmp12-_ZL10ParseErrorPKci
	.cfi_endproc

	.align	16, 0x90
	.type	_ZL23PrintCommandLineOptionsPci,@function
_ZL23PrintCommandLineOptionsPci:        # @_ZL23PrintCommandLineOptionsPci
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp13:
	.cfi_def_cfa_offset 16
.Ltmp14:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp15:
	.cfi_def_cfa_register %rbp
	subq	$16, %rsp
	movq	%rdi, -8(%rbp)
	movl	%esi, -12(%rbp)
	testl	%esi, %esi
	jne	.LBB3_2
# BB#1:                                 # %if.then
	movq	-8(%rbp), %rsi
	movl	$.L.str36, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str37, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str38, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str39, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str40, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str41, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str42, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str43, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str44, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str45, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str46, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str47, %edi
	xorl	%eax, %eax
	callq	printf
	movl	$.L.str48, %edi
	xorl	%eax, %eax
	callq	printf
.LBB3_2:                                # %if.end
	addq	$16, %rsp
	popq	%rbp
	retq
.Ltmp16:
	.size	_ZL23PrintCommandLineOptionsPci, .Ltmp16-_ZL23PrintCommandLineOptionsPci
	.cfi_endproc

	.section	.rodata.cst8,"aM",@progbits,8
	.align	8
.LCPI4_0:
	.quad	4696837146684686336     # double 1.0E+6
.LCPI4_1:
	.quad	4652007308841189376     # double 1000
	.text
	.globl	_Z25VerifyAndWriteFinalOutputdR6Domainii
	.align	16, 0x90
	.type	_Z25VerifyAndWriteFinalOutputdR6Domainii,@function
_Z25VerifyAndWriteFinalOutputdR6Domainii: # @_Z25VerifyAndWriteFinalOutputdR6Domainii
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp17:
	.cfi_def_cfa_offset 16
.Ltmp18:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp19:
	.cfi_def_cfa_register %rbp
	subq	$112, %rsp
	movsd	%xmm0, -8(%rbp)
	movq	%rdi, -16(%rbp)
	movl	%esi, -20(%rbp)
	movl	%edx, -24(%rbp)
	movsd	.LCPI4_0(%rip), %xmm0
	movsd	%xmm0, -104(%rbp)       # 8-byte Spill
	movsd	-8(%rbp), %xmm1
	mulsd	%xmm0, %xmm1
	movsd	%xmm1, -112(%rbp)       # 8-byte Spill
	movq	-16(%rbp), %rdi
	callq	_ZN6Domain5cycleEv
	cvtsi2sdl	(%rax), %xmm0
	movsd	-112(%rbp), %xmm1       # 8-byte Reload
	divsd	%xmm0, %xmm1
	movl	-20(%rbp), %eax
	movl	%eax, %ecx
	imull	%ecx, %ecx
	imull	%eax, %ecx
	xorps	%xmm0, %xmm0
	cvtsi2sdl	%ecx, %xmm0
	divsd	%xmm0, %xmm1
	movsd	%xmm1, -32(%rbp)
	movsd	-104(%rbp), %xmm0       # 8-byte Reload
	mulsd	-8(%rbp), %xmm0
	movsd	%xmm0, -104(%rbp)       # 8-byte Spill
	movq	-16(%rbp), %rdi
	callq	_ZN6Domain5cycleEv
	cvtsi2sdl	(%rax), %xmm0
	movsd	-104(%rbp), %xmm1       # 8-byte Reload
	divsd	%xmm0, %xmm1
	movl	-20(%rbp), %eax
	movl	%eax, %ecx
	imull	%ecx, %ecx
	imull	%eax, %ecx
	imull	-24(%rbp), %ecx
	xorps	%xmm0, %xmm0
	cvtsi2sdl	%ecx, %xmm0
	divsd	%xmm0, %xmm1
	movsd	%xmm1, -40(%rbp)
	movl	$0, -44(%rbp)
	movl	$.L.str24, %edi
	xorl	%eax, %eax
	callq	printf
	movl	-20(%rbp), %esi
	movl	$.L.str25, %edi
	xorl	%eax, %eax
	callq	printf
	movl	-24(%rbp), %esi
	movl	$.L.str26, %edi
	xorl	%eax, %eax
	callq	printf
	movq	-16(%rbp), %rdi
	callq	_ZN6Domain5cycleEv
	movl	(%rax), %esi
	movl	$.L.str27, %edi
	xorl	%eax, %eax
	callq	printf
	movq	-16(%rbp), %rdi
	movl	-44(%rbp), %esi
	callq	_ZN6Domain1eEi
	movsd	(%rax), %xmm0
	movl	$.L.str28, %edi
	movb	$1, %al
	callq	printf
	movq	$0, -56(%rbp)
	movq	$0, -64(%rbp)
	movq	$0, -72(%rbp)
	movl	$0, -76(%rbp)
	jmp	.LBB4_1
	.align	16, 0x90
.LBB4_9:                                # %for.inc40
                                        #   in Loop: Header=BB4_1 Depth=1
	incl	-76(%rbp)
.LBB4_1:                                # %for.cond
                                        # =>This Loop Header: Depth=1
                                        #     Child Loop BB4_3 Depth 2
	movl	-76(%rbp), %eax
	cmpl	-20(%rbp), %eax
	jge	.LBB4_10
# BB#2:                                 # %for.body
                                        #   in Loop: Header=BB4_1 Depth=1
	movl	-76(%rbp), %eax
	incl	%eax
	movl	%eax, -80(%rbp)
	jmp	.LBB4_3
	.align	16, 0x90
.LBB4_8:                                # %for.inc
                                        #   in Loop: Header=BB4_3 Depth=2
	incl	-80(%rbp)
.LBB4_3:                                # %for.cond21
                                        #   Parent Loop BB4_1 Depth=1
                                        # =>  This Inner Loop Header: Depth=2
	movl	-80(%rbp), %eax
	cmpl	-20(%rbp), %eax
	jge	.LBB4_9
# BB#4:                                 # %for.body23
                                        #   in Loop: Header=BB4_3 Depth=2
	movq	-16(%rbp), %rdi
	movl	-76(%rbp), %esi
	imull	-20(%rbp), %esi
	addl	-80(%rbp), %esi
	callq	_ZN6Domain1eEi
	movsd	(%rax), %xmm0
	movsd	%xmm0, -104(%rbp)       # 8-byte Spill
	movq	-16(%rbp), %rdi
	movl	-80(%rbp), %esi
	imull	-20(%rbp), %esi
	addl	-76(%rbp), %esi
	callq	_ZN6Domain1eEi
	movsd	-104(%rbp), %xmm0       # 8-byte Reload
	subsd	(%rax), %xmm0
	callq	_Z4FABSd
	movsd	%xmm0, -88(%rbp)
	addsd	-64(%rbp), %xmm0
	movsd	%xmm0, -64(%rbp)
	movsd	-88(%rbp), %xmm0
	ucomisd	-56(%rbp), %xmm0
	jbe	.LBB4_6
# BB#5:                                 # %if.then
                                        #   in Loop: Header=BB4_3 Depth=2
	movsd	-88(%rbp), %xmm0
	movsd	%xmm0, -56(%rbp)
.LBB4_6:                                # %if.end
                                        #   in Loop: Header=BB4_3 Depth=2
	movsd	-88(%rbp), %xmm0
	movsd	%xmm0, -104(%rbp)       # 8-byte Spill
	movq	-16(%rbp), %rdi
	movl	-80(%rbp), %esi
	imull	-20(%rbp), %esi
	addl	-76(%rbp), %esi
	callq	_ZN6Domain1eEi
	movsd	-104(%rbp), %xmm0       # 8-byte Reload
	divsd	(%rax), %xmm0
	movsd	%xmm0, -96(%rbp)
	ucomisd	-72(%rbp), %xmm0
	jbe	.LBB4_8
# BB#7:                                 # %if.then38
                                        #   in Loop: Header=BB4_3 Depth=2
	movsd	-96(%rbp), %xmm0
	movsd	%xmm0, -72(%rbp)
	jmp	.LBB4_8
.LBB4_10:                               # %for.end42
	movl	$.L.str29, %edi
	xorl	%eax, %eax
	callq	printf
	movsd	-56(%rbp), %xmm0
	movl	$.L.str30, %edi
	movb	$1, %al
	callq	printf
	movsd	-64(%rbp), %xmm0
	movl	$.L.str31, %edi
	movb	$1, %al
	callq	printf
	movsd	-72(%rbp), %xmm0
	movl	$.L.str32, %edi
	movb	$1, %al
	callq	printf
	movsd	-8(%rbp), %xmm0
	movl	$.L.str33, %edi
	movb	$1, %al
	callq	printf
	movsd	-32(%rbp), %xmm0
	movsd	-40(%rbp), %xmm1
	movl	$.L.str34, %edi
	movb	$2, %al
	callq	printf
	movsd	.LCPI4_1(%rip), %xmm0
	divsd	-40(%rbp), %xmm0
	movl	$.L.str35, %edi
	movb	$1, %al
	callq	printf
	addq	$112, %rsp
	popq	%rbp
	retq
.Ltmp20:
	.size	_Z25VerifyAndWriteFinalOutputdR6Domainii, .Ltmp20-_Z25VerifyAndWriteFinalOutputdR6Domainii
	.cfi_endproc

	.section	.text._ZN6Domain5cycleEv,"axG",@progbits,_ZN6Domain5cycleEv,comdat
	.weak	_ZN6Domain5cycleEv
	.align	16, 0x90
	.type	_ZN6Domain5cycleEv,@function
_ZN6Domain5cycleEv:                     # @_ZN6Domain5cycleEv
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp21:
	.cfi_def_cfa_offset 16
.Ltmp22:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp23:
	.cfi_def_cfa_register %rbp
	movq	%rdi, -8(%rbp)
	leaq	1304(%rdi), %rax
	popq	%rbp
	retq
.Ltmp24:
	.size	_ZN6Domain5cycleEv, .Ltmp24-_ZN6Domain5cycleEv
	.cfi_endproc

	.section	.text._ZN6Domain1eEi,"axG",@progbits,_ZN6Domain1eEi,comdat
	.weak	_ZN6Domain1eEi
	.align	16, 0x90
	.type	_ZN6Domain1eEi,@function
_ZN6Domain1eEi:                         # @_ZN6Domain1eEi
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp25:
	.cfi_def_cfa_offset 16
.Ltmp26:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp27:
	.cfi_def_cfa_register %rbp
	subq	$16, %rsp
	movq	%rdi, -8(%rbp)
	movl	%esi, -12(%rbp)
	movl	$824, %edi              # imm = 0x338
	addq	-8(%rbp), %rdi
	movslq	-12(%rbp), %rsi
	callq	_ZNSt6vectorIdSaIdEEixEm
	addq	$16, %rsp
	popq	%rbp
	retq
.Ltmp28:
	.size	_ZN6Domain1eEi, .Ltmp28-_ZN6Domain1eEi
	.cfi_endproc

	.section	.rodata.cst16,"aM",@progbits,16
	.align	16
.LCPI7_0:
	.quad	9223372036854775807     # 0x7fffffffffffffff
	.quad	9223372036854775807     # 0x7fffffffffffffff
	.section	.text._Z4FABSd,"axG",@progbits,_Z4FABSd,comdat
	.weak	_Z4FABSd
	.align	16, 0x90
	.type	_Z4FABSd,@function
_Z4FABSd:                               # @_Z4FABSd
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp29:
	.cfi_def_cfa_offset 16
.Ltmp30:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp31:
	.cfi_def_cfa_register %rbp
	movsd	%xmm0, -8(%rbp)
	andpd	.LCPI7_0(%rip), %xmm0
	popq	%rbp
	retq
.Ltmp32:
	.size	_Z4FABSd, .Ltmp32-_Z4FABSd
	.cfi_endproc

	.section	.text._ZNSt6vectorIdSaIdEEixEm,"axG",@progbits,_ZNSt6vectorIdSaIdEEixEm,comdat
	.weak	_ZNSt6vectorIdSaIdEEixEm
	.align	16, 0x90
	.type	_ZNSt6vectorIdSaIdEEixEm,@function
_ZNSt6vectorIdSaIdEEixEm:               # @_ZNSt6vectorIdSaIdEEixEm
	.cfi_startproc
# BB#0:                                 # %entry
	pushq	%rbp
.Ltmp33:
	.cfi_def_cfa_offset 16
.Ltmp34:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
.Ltmp35:
	.cfi_def_cfa_register %rbp
	movq	%rdi, -8(%rbp)
	movq	%rsi, -16(%rbp)
	movq	-8(%rbp), %rcx
	leaq	(,%rsi,8), %rax
	addq	(%rcx), %rax
	popq	%rbp
	retq
.Ltmp36:
	.size	_ZNSt6vectorIdSaIdEEixEm, .Ltmp36-_ZNSt6vectorIdSaIdEEixEm
	.cfi_endproc

	.type	.L.str,@object          # @.str
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str:
	.asciz	"-i"
	.size	.L.str, 3

	.type	.L.str1,@object         # @.str1
.L.str1:
	.asciz	"Missing integer argument to -i"
	.size	.L.str1, 31

	.type	.L.str2,@object         # @.str2
.L.str2:
	.asciz	"Parse Error on option -i integer value required after argument\n"
	.size	.L.str2, 64

	.type	.L.str3,@object         # @.str3
.L.str3:
	.asciz	"-s"
	.size	.L.str3, 3

	.type	.L.str4,@object         # @.str4
.L.str4:
	.asciz	"Missing integer argument to -s\n"
	.size	.L.str4, 32

	.type	.L.str5,@object         # @.str5
.L.str5:
	.asciz	"Parse Error on option -s integer value required after argument\n"
	.size	.L.str5, 64

	.type	.L.str6,@object         # @.str6
.L.str6:
	.asciz	"-r"
	.size	.L.str6, 3

	.type	.L.str7,@object         # @.str7
.L.str7:
	.asciz	"Missing integer argument to -r\n"
	.size	.L.str7, 32

	.type	.L.str8,@object         # @.str8
.L.str8:
	.asciz	"Parse Error on option -r integer value required after argument\n"
	.size	.L.str8, 64

	.type	.L.str9,@object         # @.str9
.L.str9:
	.asciz	"-f"
	.size	.L.str9, 3

	.type	.L.str10,@object        # @.str10
.L.str10:
	.asciz	"Missing integer argument to -f\n"
	.size	.L.str10, 32

	.type	.L.str11,@object        # @.str11
.L.str11:
	.asciz	"Parse Error on option -f integer value required after argument\n"
	.size	.L.str11, 64

	.type	.L.str12,@object        # @.str12
.L.str12:
	.asciz	"-p"
	.size	.L.str12, 3

	.type	.L.str13,@object        # @.str13
.L.str13:
	.asciz	"-q"
	.size	.L.str13, 3

	.type	.L.str14,@object        # @.str14
.L.str14:
	.asciz	"-b"
	.size	.L.str14, 3

	.type	.L.str15,@object        # @.str15
.L.str15:
	.asciz	"Missing integer argument to -b\n"
	.size	.L.str15, 32

	.type	.L.str16,@object        # @.str16
.L.str16:
	.asciz	"Parse Error on option -b integer value required after argument\n"
	.size	.L.str16, 64

	.type	.L.str17,@object        # @.str17
.L.str17:
	.asciz	"-c"
	.size	.L.str17, 3

	.type	.L.str18,@object        # @.str18
.L.str18:
	.asciz	"Missing integer argument to -c\n"
	.size	.L.str18, 32

	.type	.L.str19,@object        # @.str19
.L.str19:
	.asciz	"Parse Error on option -c integer value required after argument\n"
	.size	.L.str19, 64

	.type	.L.str20,@object        # @.str20
.L.str20:
	.asciz	"-v"
	.size	.L.str20, 3

	.type	.L.str21,@object        # @.str21
.L.str21:
	.asciz	"Use of -v requires compiling with -DVIZ_MESH\n"
	.size	.L.str21, 46

	.type	.L.str22,@object        # @.str22
.L.str22:
	.asciz	"-h"
	.size	.L.str22, 3

	.type	.L.str23,@object        # @.str23
.L.str23:
	.asciz	"ERROR: Unknown command line argument: %s\n"
	.size	.L.str23, 42

	.type	.L.str24,@object        # @.str24
.L.str24:
	.asciz	"Run completed:  \n"
	.size	.L.str24, 18

	.type	.L.str25,@object        # @.str25
.L.str25:
	.asciz	"   Problem size        =  %i \n"
	.size	.L.str25, 31

	.type	.L.str26,@object        # @.str26
.L.str26:
	.asciz	"   MPI tasks           =  %i \n"
	.size	.L.str26, 31

	.type	.L.str27,@object        # @.str27
.L.str27:
	.asciz	"   Iteration count     =  %i \n"
	.size	.L.str27, 31

	.type	.L.str28,@object        # @.str28
.L.str28:
	.asciz	"   Final Origin Energy = %12.6e \n"
	.size	.L.str28, 34

	.type	.L.str29,@object        # @.str29
.L.str29:
	.asciz	"   Testing Plane 0 of Energy Array on rank 0:\n"
	.size	.L.str29, 47

	.type	.L.str30,@object        # @.str30
.L.str30:
	.asciz	"        MaxAbsDiff   = %12.6e\n"
	.size	.L.str30, 31

	.type	.L.str31,@object        # @.str31
.L.str31:
	.asciz	"        TotalAbsDiff = %12.6e\n"
	.size	.L.str31, 31

	.type	.L.str32,@object        # @.str32
.L.str32:
	.asciz	"        MaxRelDiff   = %12.6e\n\n"
	.size	.L.str32, 32

	.type	.L.str33,@object        # @.str33
.L.str33:
	.asciz	"\nElapsed time         = %10.2f (s)\n"
	.size	.L.str33, 36

	.type	.L.str34,@object        # @.str34
.L.str34:
	.asciz	"Grind time (us/z/c)  = %10.8g (per dom)  (%10.8g overall)\n"
	.size	.L.str34, 59

	.type	.L.str35,@object        # @.str35
.L.str35:
	.asciz	"FOM                  = %10.8g (z/s)\n\n"
	.size	.L.str35, 38

	.type	.L.str36,@object        # @.str36
.L.str36:
	.asciz	"Usage: %s [opts]\n"
	.size	.L.str36, 18

	.type	.L.str37,@object        # @.str37
.L.str37:
	.asciz	" where [opts] is one or more of:\n"
	.size	.L.str37, 34

	.type	.L.str38,@object        # @.str38
.L.str38:
	.asciz	" -q              : quiet mode - suppress all stdout\n"
	.size	.L.str38, 53

	.type	.L.str39,@object        # @.str39
.L.str39:
	.asciz	" -i <iterations> : number of cycles to run\n"
	.size	.L.str39, 44

	.type	.L.str40,@object        # @.str40
.L.str40:
	.asciz	" -s <size>       : length of cube mesh along side\n"
	.size	.L.str40, 51

	.type	.L.str41,@object        # @.str41
.L.str41:
	.asciz	" -r <numregions> : Number of distinct regions (def: 11)\n"
	.size	.L.str41, 57

	.type	.L.str42,@object        # @.str42
.L.str42:
	.asciz	" -b <balance>    : Load balance between regions of a domain (def: 1)\n"
	.size	.L.str42, 70

	.type	.L.str43,@object        # @.str43
.L.str43:
	.asciz	" -c <cost>       : Extra cost of more expensive regions (def: 1)\n"
	.size	.L.str43, 66

	.type	.L.str44,@object        # @.str44
.L.str44:
	.asciz	" -f <numfiles>   : Number of files to split viz dump into (def: (np+10)/9)\n"
	.size	.L.str44, 76

	.type	.L.str45,@object        # @.str45
.L.str45:
	.asciz	" -p              : Print out progress\n"
	.size	.L.str45, 39

	.type	.L.str46,@object        # @.str46
.L.str46:
	.asciz	" -v              : Output viz file (requires compiling with -DVIZ_MESH\n"
	.size	.L.str46, 72

	.type	.L.str47,@object        # @.str47
.L.str47:
	.asciz	" -h              : This message\n"
	.size	.L.str47, 33

	.type	.L.str48,@object        # @.str48
.L.str48:
	.asciz	"\n\n"
	.size	.L.str48, 3

	.type	.L.str49,@object        # @.str49
.L.str49:
	.asciz	"%s\n"
	.size	.L.str49, 4


	.ident	"clang version 3.6.0 (trunk 216898)"
	.section	".note.GNU-stack","",@progbits
